Course: Android App Development
Topic: Installing Android SDK and Required Development Tools
Course Link: Android App Development Course
Demo Link: Register for a Free Course Demo
Website: JustAcademy
Before developing Android applications, a developer must prepare a suitable development environment. This environment includes an Integrated Development Environment (IDE), the Android Software Development Kit (SDK), build tools, platform tools, an emulator or physical Android device, and supporting components.
The Android SDK provides the libraries, platform APIs, debugging utilities, and build-related tools needed to create, test, debug, and package Android applications. Android Studio is the official IDE for Android development and provides an interface for managing most of these components.
Installing the required tools correctly helps developers create projects, write Kotlin or Java code, design application interfaces, run applications, and identify errors during development.
For official installation instructions, visit the Android Studio Installation Guide.
After completing this topic, learners should be able to:
The Android Software Development Kit (SDK) is a collection of development tools, libraries, platform files, and utilities used to build Android applications. It allows developers to compile source code, communicate with Android devices, test applications, and prepare installable application packages.
| Feature | Android Studio | Android SDK |
|---|---|---|
| Type | Integrated development environment (IDE) | Collection of development packages and tools |
| Main purpose | Writing, organizing, running, and debugging code through a development interface | Providing APIs and utilities to build and test Android apps |
| Code editor | Includes a code editor | Does not provide a complete graphical code editor by itself |
| SDK management | Includes SDK Manager for installing and updating packages | Contains the SDK packages managed by SDK Manager or command-line tools |
| Build support | Integrates with Gradle and Android build tools | Includes tools needed by the Android build process |
A standard Android development setup uses several components. Android Studio simplifies their installation and management.
| Tool | Purpose | Example Use |
|---|---|---|
| Android Studio | IDE for coding, designing, building, and debugging | Creating a Kotlin-based application |
| Android SDK Platform | Provides platform APIs for a selected Android version | Compiling against a particular Android API level |
| Android SDK Build-Tools | Provides utilities used to build and package applications | Generating an APK or app bundle |
| Android SDK Platform-Tools | Includes tools such as Android Debug Bridge (ADB) | Installing an app on a connected device |
| Android SDK Command-Line Tools | Provides command-line utilities, including SDK package management tools | Installing SDK packages using sdkmanager |
| Android Emulator | Runs virtual Android devices on a computer | Testing an app without a physical phone |
| System Image | Contains the Android operating system image used by an emulator | Launching a virtual device with a selected API level |
| Gradle and Android Gradle Plugin | Manage and execute the application build process | Resolving dependencies and compiling an app |
| JDK | Provides Java development and runtime tools needed by Java-based build tooling | Supporting Gradle and Java-related development tasks |
Before installing Android Studio, check whether the computer meets the requirements for the selected operating system and intended workload. Running Android Studio alone generally requires fewer resources than running multiple emulators or building a large application.
System requirements can change between releases. Check the official Android Studio installation and requirements page before downloading.
Android Studio is the recommended starting point because its setup wizard helps install the IDE and configure the Android SDK.
Important: Download Android Studio and SDK components from official sources whenever possible. Avoid unknown third-party installers because they may be outdated or unsafe.
Exact installer screens and menu labels can vary by operating system and Android Studio release.
When Android Studio opens for the first time, the setup wizard helps configure the development environment. It may ask you to select a setup type, review settings, accept licenses, and download additional components.
Do not close Android Studio while essential packages are being installed unless the process has become unresponsive. If a download fails, review the error and retry the affected package.
The SDK directory stores the Android platforms and tools installed on the computer. Android Studio normally manages these packages through SDK Manager.
| Folder | Purpose |
|---|---|
platforms |
Contains installed Android SDK platform packages. |
platform-tools |
Contains utilities such as adb. |
build-tools |
Contains tools used to build and package Android applications. |
cmdline-tools |
Contains Android SDK command-line utilities, including sdkmanager. |
emulator |
Contains Android Emulator components when installed. |
system-images |
Contains Android system images used by virtual devices. |
licenses |
Stores accepted SDK license records for installed packages. |
To find the SDK path in Android Studio:
For example, a Windows installation might use a path such as C:\Users\YourUser\AppData\Local\Android\Sdk. A macOS installation might use /Users/YourUser/Library/Android/sdk. These are examples only; your actual location may differ.
An Android SDK Platform provides the API definitions and files associated with a particular Android version. A project specifies the API level against which it compiles, and developers can install additional platforms for compatibility and testing.
An API level is an integer that identifies a version of the Android framework API. Android projects use API-level settings to describe which platform APIs are available during compilation and the range of devices the application intends to support.
| Setting | Meaning |
|---|---|
minSdk |
The minimum Android API level the app supports for installation, subject to platform rules. |
targetSdk |
The API level the app is designed and tested to behave against, including relevant platform behavior changes. |
compileSdk |
The API level used to compile the application and access the corresponding SDK APIs. |
These settings serve different purposes. A higher compileSdk does not automatically mean the application can run only on devices with that API level; the minimum supported API is controlled separately by minSdk.
Android SDK Build-Tools contain utilities used by the Android build process to compile, optimize, package, and sign application artifacts. Android Gradle Plugin versions typically specify compatible build-tool requirements, so developers should allow the build system to use supported versions rather than arbitrarily selecting an older package.
If a project reports that build tools are missing, read the exact version in the error message and install a compatible version through SDK Manager.
Platform-Tools provide utilities that support communication between the development computer and Android devices. The best-known utility is Android Debug Bridge (ADB).
ADB is a command-line tool that lets developers communicate with a running Android device or emulator. It supports tasks such as listing connected devices, installing application packages, viewing logs, and opening a device shell.
Open Command Prompt, PowerShell, or a terminal. If the platform-tools directory is available on your PATH, run:
adb version
adb devicesThe first command displays the installed ADB version. The second lists devices that ADB can detect. If ADB is not recognized, run it from the platform-tools directory or configure the directory in your PATH.
Command-line tools let developers manage SDK packages and perform certain development tasks without relying entirely on graphical menus. They are useful for automation, continuous integration, build servers, and advanced workflows.
The SDK command-line tools include sdkmanager, which can list, install, update, and manage SDK packages.
After installing the command-line tools and configuring the correct paths, use commands such as:
sdkmanager --listThis lists available and installed SDK packages. To install a package, use its exact package identifier from the list, for example:
sdkmanager "platform-tools"For packages that require license acceptance, follow the SDK tools' license instructions. In automated environments, ensure the necessary licenses are accepted and the correct SDK directory is configured.
The Android Emulator allows an application to run in a virtual Android device on the development computer. It is useful for testing different Android versions, screen sizes, resolutions, and device configurations without owning every physical device.
Emulator performance depends on the computer's processor, memory, operating system, and virtualization configuration. Ensure hardware virtualization is supported and enabled where required by the operating system and emulator configuration. Follow the official instructions for your platform rather than changing firmware settings without understanding their effects.
An Android Virtual Device (AVD) is a configuration describing the virtual device that the emulator will run. It specifies characteristics such as the device profile, Android system image, and storage configuration.
The JDK includes tools and runtime components used by Java-related development and build tooling. Android Studio commonly manages or selects a suitable JDK for Gradle builds. You should use a JDK version compatible with your Android Gradle Plugin and Gradle versions.
To check whether a Java command is available in your terminal, run:
java -versionThe output shows the Java runtime version selected by the terminal. It does not necessarily identify the JDK configured for every Android Studio project.
Gradle is a build automation system used to compile code, process resources, resolve dependencies, run tests, and package Android applications. Android projects use the Android Gradle Plugin to add Android-specific build functionality.
Many Android Studio projects include a Gradle wrapper. It allows a project to use its configured Gradle version without requiring the developer to install that exact version globally.
From a project's root directory, the wrapper can commonly be run with:
gradlew.bat tasksOn macOS or Linux, use:
./gradlew tasksThese commands list available Gradle tasks when the project and build environment are configured correctly.
Environment variables can make Android command-line tools accessible from different terminal locations. Android Studio can work without manually adding every SDK tool to PATH, but command-line workflows often benefit from a configured SDK location.
ANDROID_HOME is commonly used to identify the Android SDK installation directory. Some existing tools or scripts may also use ANDROID_SDK_ROOT; check the documentation for the tools you use and avoid configuring conflicting SDK paths.
Adding the platform-tools directory to PATH allows you to run commands such as adb without typing the complete file path.
Example directory on Windows:
C:\Users\YourUser\AppData\Local\Android\Sdk\platform-toolsExample directory on macOS:
/Users/YourUser/Library/Android/sdk/platform-toolsThese paths are examples only. Always use the SDK location shown in your Android Studio settings.
ANDROID_HOME with the actual SDK directory.platform-tools directory to the user or system PATH as appropriate.adb version to verify access.Depending on your shell, environment variables can be set in a shell startup file. For example, a Bash or Zsh configuration may include lines similar to the following. Replace the sample directory with your actual SDK location.
export ANDROID_HOME="$HOME/Android/Sdk"
export PATH="$PATH:$ANDROID_HOME/platform-tools"After updating the appropriate configuration file, reload it or open a new terminal. Verify the result with:
echo "$ANDROID_HOME"
adb versionDo not copy sample paths blindly. Incorrect paths may cause Android Studio, Gradle, and terminal commands to use different SDK installations.
After the development tools are installed, create a small project to confirm that the IDE, SDK, Gradle, and emulator work together.
FirstAndroidApp.If the project builds and runs, it is a strong initial indication that the development environment is working correctly.
An emulator is not the only way to run an Android application. Developers can also use a physical Android phone or tablet, which is particularly useful for testing camera behavior, sensors, performance, connectivity, and real-device interactions.
adb devices in a terminal or inspect the device list in Android Studio.Only enable debugging on devices you trust. Revoke debugging authorizations and disable USB debugging when it is no longer needed, particularly on shared or public computers.
Once the tools are installed, verify each important component instead of assuming the setup is complete.
| Verification | How to Check | Expected Result |
|---|---|---|
| Android Studio | Launch the IDE | The welcome screen or project window opens successfully |
| SDK location | Open SDK Manager | The SDK directory is displayed |
| SDK platform | Review SDK Platforms | The required platform is installed |
| Build-Tools | Review SDK Tools or project build output | A compatible version is available |
| ADB | Run adb version |
The installed ADB version is displayed |
| Device connection | Run adb devices |
The emulator or authorized device is listed |
| Emulator | Start the AVD | The virtual Android device boots successfully |
| Gradle | Build a sample project | The build completes without unresolved configuration errors |
| App execution | Run the sample project | The app launches on the selected device |
| Problem | Possible Cause | Suggested Solution |
|---|---|---|
| Android Studio installer will not start | Incomplete download, unsupported OS, or permissions issue | Download the correct official package again and review system requirements. |
| SDK download fails | Unstable internet, proxy, firewall, or repository issue | Check connectivity, proxy settings, and the reported download error, then retry. |
| SDK package is missing | The required platform or tool was not installed | Open SDK Manager and install the package requested by the project. |
adb is not recognized |
Platform-tools is not installed or is missing from PATH | Install Platform-Tools and verify the directory used in PATH. |
| Emulator is slow | Limited memory, unsuitable system image, or virtualization configuration | Check hardware requirements, free system resources, and emulator configuration. |
| AVD fails to start | Incompatible image, corrupted AVD, or insufficient resources | Review emulator output, try a compatible image, or recreate the AVD. |
| Gradle sync fails | Network issues, incompatible plugin/JDK versions, or incorrect project configuration | Read the sync error, check version compatibility, and retry after resolving the cause. |
| Device is unauthorized | The device has not approved the computer's debugging key | Unlock the device and approve the USB debugging authorization prompt. |
| Insufficient disk space | Many SDK platforms, images, or caches are installed | Free disk space and remove only SDK packages or AVDs that are no longer required. |
| License error | Required SDK licenses have not been accepted | Review and accept the relevant licenses through SDK Manager or the documented command-line workflow. |
Objective: Install the Android development tools and verify that a sample application can run.
FirstAndroidApp.At the end of the exercise, the learner should have a working Android Studio installation, an accessible SDK, the required build tools, a usable emulator or physical device connection, and a sample application that builds and launches successfully.
Answer: The Android SDK is a collection of platform APIs, libraries, and development utilities used to build, test, debug, and package Android applications.
Answer: Android Studio is the official integrated development environment for Android development. It provides a code editor, project tools, build integration, debugging support, and SDK management.
Answer: An SDK Platform provides APIs and files for a particular Android API level. SDK Build-Tools provide utilities used to compile, optimize, and package applications.
Answer: Android Debug Bridge is a command-line tool for communicating with Android devices and emulators. It supports operations such as listing devices, installing apps, and viewing logs.
Answer: An AVD is a configuration used by the Android Emulator to simulate an Android device with a chosen profile and system image.
Answer: The system image provides the Android operating system environment that the virtual device runs.
Answer: SDK Manager helps developers install, update, and manage Android SDK platforms and tools.
minSdk and targetSdk?Answer: minSdk identifies the minimum Android API level supported for installation, while targetSdk indicates the API level against which the app is designed and tested for relevant platform behavior changes.
adb command not work?Answer: Platform-Tools may be missing, or its directory may not be available through PATH. The developer should verify installation and the configured directory.
Answer: Yes. Developers can run and test applications on a compatible physical Android device. Cloud-based device services may also be available for supported workflows.
Answer: Gradle automates build tasks such as dependency resolution, compilation, resource processing, testing, and packaging.
Answer: Launch Android Studio, confirm the required SDK packages are installed, check ADB where needed, create a sample project, build it, and run it on an emulator or physical device.
Installing the Android SDK and required development tools is a foundational step in Android application development. Android Studio provides a convenient starting point for managing SDK platforms, build tools, command-line utilities, and emulators. Once these components are installed and verified, developers can create projects, compile source code, test application behavior, and debug issues in a structured development environment.
Practicing the complete setup—from installation and SDK configuration to running a sample application—helps learners build confidence before moving on to Kotlin programming, application components, layouts, navigation, data storage, networking, and deployment.
To continue learning, visit JustAcademy's Android App Development Course, explore the JustAcademy website, or register for a course demo.
